package social.server.main;

import java.util.Iterator;
import java.util.List;

import social.server.Exceptions.InexistentPublicationException;
import social.server.Exceptions.InvalidAtributeException;
import social.server.Exceptions.InvalidCategoryException;
import social.server.Exceptions.InvalidIdItemExeption;
import social.server.Exceptions.InvalidIdPublicationException;
import social.server.Exceptions.InvalidIdSessionException;
import social.server.Exceptions.InvalidItemDescriptionException;
import social.server.Exceptions.InvalidKeyException;
import social.server.Exceptions.InvalidKeyWordException;
import social.server.Exceptions.InvalidLoginException;
import social.server.Exceptions.InvalidNameAtributeException;
import social.server.Exceptions.InvalidSortingCriterionException;
import social.server.Exceptions.InvalidSortingTypeException;
import social.server.Exceptions.NoAtributeFoundException;
import social.server.Exceptions.NoCategoryFoundException;
import social.server.Exceptions.NoIdSessionFoundException;
import social.server.Exceptions.NoSortingCriterionFoundException;
import social.server.Exceptions.NoSortingTypeFoundException;
import social.server.historicActivity.HistoricActivity;
import social.server.historicActivity.PublicateRequestActivity;

/**
 * Classe responsavel por manter metodos usados para validar entradas
 * especificas.
 * 
 * @author *
 * 
 */
public class Validator {

	/**
	 * Valida ou nao uma String correspondente a um atributo de um usuario.
	 * 
	 * @param atribute
	 *            Atributo a ser validado.
	 * @return Retorna o resultado da operacao.
	 * @throws NoAtributeFoundException
	 *             Lanca exception caso o atributo nao exista.
	 * @throws InvalidAtributeException
	 *             Lanca exception caso o atributo seja invalido.
	 */
	public static boolean validateUserAtribute(String atribute)
			throws NoAtributeFoundException, InvalidAtributeException {
		if (atribute == null || atribute.isEmpty()) {
			throw new InvalidAtributeException();
		}
		for (int i = 0; i < System.userAtributes.length; i++) {
			System.getInstance();
			if (System.userAtributes[i].equalsIgnoreCase(atribute)) {
				return true;
			}
		}

		throw new NoAtributeFoundException();
	}

	/**
	 * Valida ou nao uma String correspondente a um atributo de um item.
	 * 
	 * @param atribute
	 *            Atributo a ser validado.
	 * @return Retorna o resultado da operacao.
	 * @throws NoAtributeFoundException
	 *             Lanca exception caso o atributo nao exista.
	 * @throws InvalidAtributeException
	 *             Lanca exception caso o atributo seja invalido.
	 */
	public static boolean validateItemAtribute(String atribute)
			throws NoAtributeFoundException, InvalidAtributeException {
		if (atribute == null || atribute.isEmpty()) {
			throw new InvalidAtributeException();
		}

		System.getInstance();
		for (int i = 0; i < System.itemAtributes.length; i++) {
			System.getInstance();
			if (System.itemAtributes[i].equalsIgnoreCase(atribute)) {
				return true;
			}
		}

		throw new NoAtributeFoundException();
	}

	/**
	 * Valida ou nao uma String correspondente a um tipo de ordenacao de item.
	 * 
	 * @param sortingType
	 *            Tipo de ordenacao a ser validado.
	 * @return O resultado da operacao.
	 * @throws NoSortingTypeFoundException
	 *             Lanca exception caso o tipo de ordenacao nao exista.
	 * @throws InvalidSortingTypeException
	 *             Lanca exception caso o tipo de ordenacao seja invalido.
	 */
	public static boolean validateItemSortingType(String sortingType)
			throws NoSortingTypeFoundException, InvalidSortingTypeException {
		if (sortingType == null || sortingType.isEmpty()) {
			throw new InvalidSortingTypeException();
		}

		System.getInstance();
		for (int i = 0; i < System.itemSortingTypes.length; i++) {
			System.getInstance();
			if (System.itemSortingTypes[i].equalsIgnoreCase(sortingType)) {
				return true;
			}
		}

		throw new NoSortingTypeFoundException();
	}

	/**
	 * Valida ou nao uma String correspondente a um criterio de ordenacao de
	 * item.
	 * 
	 * @param sortingCriterion
	 *            Criterio de ordenacao a ser validado.
	 * @return O resultado da operacao.
	 * @throws NoSortingCriterionFoundException
	 *             Lanca exception caso o criterio de ordenacao nao exista.
	 * @throws InvalidSortingCriterionException
	 *             Lanca exception caso o criterio de ordenacao seja invalido.
	 */
	public static boolean validateItemSortingCriterion(String sortingCriterion)
			throws NoSortingCriterionFoundException,
			InvalidSortingCriterionException {
		if (sortingCriterion == null || sortingCriterion.isEmpty()) {
			throw new InvalidSortingCriterionException();
		}

		System.getInstance();
		for (int i = 0; i < System.itemSortingTypes.length; i++) {
			System.getInstance();
			if (System.itemSortingCriterion[i]
					.equalsIgnoreCase(sortingCriterion)) {
				return true;
			}
		}
		throw new NoSortingCriterionFoundException();
	}

	/**
	 * Valida ou nao uma String correspondente a uma id de sessao.
	 * 
	 * @param idSessao
	 *            Id sessao a ser validado.
	 * @return O resultado da operacao.
	 * @throws InvalidIdSessionException
	 *             Lanca exception caso o id de sessao nao exista.
	 * @throws NoIdSessionFoundException
	 *             Lanca exception caso o id de sessao seja invalida.
	 */
	public static boolean validateIdSection(String idSessao)
			throws InvalidIdSessionException, NoIdSessionFoundException {
		if (idSessao == null || idSessao.isEmpty()) {
			throw new InvalidIdSessionException();
		}
		Iterator<User> it = System.getInstance().getUserList().iterator();
		while (it.hasNext()) {
			User user = it.next();
			if (user.getIdSession().equalsIgnoreCase(idSessao)) {
				return true;
			}
		}
		throw new NoIdSessionFoundException();
	}

	/**
	 * Valida ou nao uma String correspondente a uma palavra chave.
	 * 
	 * @param key
	 *            Palavra chave a ser validada.
	 * @return O resultado da operacao.
	 * @throws InvalidKeyWordException
	 *             Lanca exception caso a palavra chave seja invalida.
	 */
	public static boolean validateKeyWord(String key)
			throws InvalidKeyWordException {
		if (key == null || key.isEmpty()) {
			throw new InvalidKeyWordException();
		}
		return true;
	}

	/**
	 * Valida ou nao uma String correspondente a uma chave.
	 * 
	 * @param key
	 *            Chave a ser validada.
	 * @return O resultado da operacao.
	 * @throws InvalidKeyException
	 *             Lanca exception caso a chave seja invalida.
	 */
	public static boolean validateKey(String key) throws InvalidKeyException {
		if (key == null || key.isEmpty()) {
			throw new InvalidKeyException();
		}
		return true;
	}

	/**
	 * Valida ou nao uma String correspondente a uma categoria.
	 * 
	 * @param category
	 *            Categoria a ser validada.
	 * @return O resultado da operacao.
	 * @throws InvalidCategoryException
	 *             Lanca exception caso a categoria seja invalida.
	 * @throws NoCategoryFoundException
	 *             Lanca exception caso a categoria nao exista.
	 */
	public static boolean validateRankingCategory(String category)
			throws InvalidCategoryException, NoCategoryFoundException {
		if (category == null || category.isEmpty()) {
			throw new InvalidCategoryException();
		}

		System.getInstance();
		for (int i = 0; i < System.rankingCategory.length; i++) {
			System.getInstance();
			if (category.equalsIgnoreCase(System.rankingCategory[i])) {
				return true;
			}
		}
		throw new NoCategoryFoundException();
	}

	public static void validateItemName(String name)
			throws InvalidNameAtributeException {
		if (name == null || name.isEmpty()) {
			throw new InvalidNameAtributeException();
		}
	}

	public static void validateDescriptionName(String name)
			throws InvalidItemDescriptionException {
		if (name == null || name.isEmpty()) {
			throw new InvalidItemDescriptionException();
		}

	}

	public static void validateIdPublication(String idPublication)
			throws Exception {
		if (idPublication == null || idPublication.isEmpty()) {
			throw new InvalidIdPublicationException();
		}
		User user = null;

		try {
			user = System.getInstance().getUser(idPublication.split("/")[0]);
		} catch (Exception e) {
			throw new InexistentPublicationException();
		}

		int cont = 0;
		List<HistoricActivity> list = user.getUserHistoric();
		for (HistoricActivity pub : list) {
			if (pub instanceof PublicateRequestActivity) {
				if (((PublicateRequestActivity) pub).getPublicationId().equals(
						idPublication)) {
					++cont;
				}
			}
		}
		if (cont == 0) {
			throw new InexistentPublicationException();
		}
	}

	public static void validateIdItem(String idItem)
			throws InvalidIdItemExeption {
		if (idItem == null || idItem.isEmpty()) {
			throw new InvalidIdItemExeption();
		}

	}

	public static void validateItemCategory(String category)
			throws InvalidCategoryException {
		if (category == null || category.isEmpty()) {
			throw new InvalidCategoryException();
		}

	}

	public static void validateUserLogin(String userLogin)
			throws InvalidLoginException {
		if (userLogin == null || userLogin.isEmpty()) {
			throw new InvalidLoginException();
		}
	}

	public static void validateIdLoan(String idLoan) throws Exception {
		if (idLoan == null || idLoan.isEmpty()) {
			throw new Exception("Identificador do empréstimo é inválido");
		}		
	}

}
